import request from '../../utils/request';

Page({

  /**
   * 页面的初始数据
   */
  data: {
    wordList: [], // 待记忆单词列表
    showAddModal: false, // 显示添加单词弹窗
    newWord: '', // 新单词输入内容
    showKeyboard: false, // 显示虚拟键盘
    currentInputIndex: -1, // 当前激活的输入框索引
    currentKeyboardInput: '', // 当前键盘输入的内容
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 页面加载时获取待记忆单词
    this.getPendingWords();
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 页面显示时刷新数据
    this.getPendingWords();
  },

  /**
   * 获取待记忆单词
   */
  getPendingWords() {
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });

    // 调用后端API获取待记忆单词
    request.get('/api/review')
      .then(res => {
        wx.hideLoading();

        if (res.code == "100") {
          // 渲染单词列表，为每个单词添加inputValue属性
          const formattedWordList = (res.data.reviewList || []).map(word => ({
            ...word,
            inputValue: '' // 初始化输入值
          }));
          this.setData({
            wordList: formattedWordList
          });
        } else {
          wx.showToast({
            title: res.message || '获取失败',
            icon: 'error',
            duration: 2000
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('获取待记忆单词失败:', err);

        wx.showToast({
          title: '网络错误',
          icon: 'error',
          duration: 2000
        });
      });
  },

  /**
   * 输入框点击事件 - 显示虚拟键盘
   */
  onInputTap(e) {
    const { inputIndex } = e.currentTarget.dataset;
    // 清空当前键盘输入
    this.setData({
      showKeyboard: true,
      currentInputIndex: inputIndex,
      currentKeyboardInput: ''
    });
  },

  /**
   * 键盘按键点击事件
   */
  onKeyPress(e) {
    const { key } = e.currentTarget.dataset;
    let currentKeyboardInput = this.data.currentKeyboardInput;

    // 处理按键
    if (key === 'DELETE') {
      // 删除最后一个字符
      currentKeyboardInput = currentKeyboardInput.slice(0, -1);
    } else if (key === 'SPACE') {
      // 添加空格
      currentKeyboardInput += ' ';
    } else {
      // 添加普通字符
      currentKeyboardInput += key;
    }

    // 更新键盘输入显示
    this.setData({
      currentKeyboardInput
    });
  },

  /**
   * 键盘确认按钮点击事件 - 将输入内容填入输入框
   */
  onKeyboardConfirm() {
    const wordList = this.data.wordList;
    const currentInputIndex = this.data.currentInputIndex;

    if (currentInputIndex === -1) return;

    // 将键盘输入的内容填入当前激活的输入框
    wordList[currentInputIndex].inputValue = this.data.currentKeyboardInput;

    // 关闭键盘并重置
    this.setData({
      wordList,
      showKeyboard: false,
      currentInputIndex: -1,
      currentKeyboardInput: ''
    });
  },

  /**
   * 播放发音
   */
  onPlayVoice(e) {
    const { voiceUrl } = e.currentTarget.dataset;

    // 检查是否有音频地址
    if (!voiceUrl) {
      wx.showToast({
        title: '无发音文件',
        icon: 'none'
      });
      return;
    }

    // 创建音频实例
    const innerAudioContext = wx.createInnerAudioContext();

    // 设置音频源
    innerAudioContext.src = voiceUrl;

    // 播放音频
    innerAudioContext.play();

    // 监听播放失败
    innerAudioContext.onError((res) => {
      console.error('播放音频失败:', res);
      wx.showToast({
        title: '播放失败',
        icon: 'error'
      });
      // 销毁音频实例
      innerAudioContext.destroy();
    });

    // 监听播放结束
    innerAudioContext.onEnded(() => {
      // 销毁音频实例
      innerAudioContext.destroy();
    });
  },

  /**
   * 关闭虚拟键盘
   */
  onKeyboardClose() {
    // 关闭键盘并重置
    this.setData({
      showKeyboard: false,
      currentInputIndex: -1,
      currentKeyboardInput: ''
    });
  },

  /**
   * 点击确认按钮
   */
  onConfirm(e) {
    const { index } = e.currentTarget.dataset;
    const { wordList } = this.data;
    const word = wordList[index];

    // 检查用户是否输入了单词
    if (!word.inputValue.trim()) {
      wx.showToast({
        title: '请输入单词',
        icon: 'none'
      });
      return;
    }

    // 显示验证提示
    wx.showLoading({
      title: '验证中...',
      mask: true
    });

    // 调用后端API验证单词
    request.post('/api/review', {
      progressId: word.id, // 假设每个单词有progressId
      reviewWord: word.inputValue, // 入参为reviewWord
      // tsno由request.js自动添加
    })
      .then(res => {
        wx.hideLoading();

        if (res.code == '100') {
          // 验证成功
          wx.showToast({
            title: '验证成功',
            icon: 'success',
            duration: 2000
          });

          // 刷新单词列表
          setTimeout(() => {
            this.getPendingWords();
          }, 1500);
        } else {
          // 验证失败
          wx.showModal({
            title: '验证失败',
            content: res.message || '请重新输入',
            showCancel: false,
            confirmText: '知道了'
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('验证单词失败:', err);

        wx.showToast({
          title: '网络错误',
          icon: 'error',
          duration: 2000
        });
      });
  },

  /**
   * 点击添加单词按钮
   */
  onAddWord() {
    // 显示添加单词弹窗
    this.setData({
      showAddModal: true,
      newWord: ''
    });
  },

  /**
   * 添加单词输入变化
   */
  onAddWordInput(e) {
    const { value } = e.detail;
    this.setData({
      newWord: value
    });
  },

  /**
   * 关闭弹窗
   */
  onModalClose() {
    this.setData({
      showAddModal: false
    });
  },

  /**
   * 停止事件冒泡
   */
  stopPropagation() {
    // 用于阻止弹窗内容点击时关闭弹窗
  },

  /**
   * 确认添加单词
   */
  onConfirmAdd() {
    // 检查输入内容
    if (!this.data.newWord.trim()) {
      wx.showToast({
        title: '请输入单词',
        icon: 'none'
      });
      return;
    }

    // 显示加载提示
    wx.showLoading({
      title: '添加中...',
      mask: true
    });

    // 调用后端API添加单词
    request.post('/api/add', {
      word: this.data.newWord, // 入参为word
      confirm: 0, // 入参为confirm
      // tsno由request.js自动添加
    })
      .then(res => {
        wx.hideLoading();

        if (res.code == '100') {
          // 添加成功
          wx.showToast({
            title: '添加成功',
            icon: 'success',
            duration: 2000
          });

          // 关闭弹窗
          this.setData({
            showAddModal: false
          });

          // 刷新单词列表
          setTimeout(() => {
            this.getPendingWords();
          }, 1500);
        } else {
          // 添加失败
          wx.showModal({
            title: '添加失败',
            content: res.message || '请重试',
            showCancel: false,
            confirmText: '知道了'
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('添加单词失败:', err);

        wx.showToast({
          title: '网络错误',
          icon: 'error',
          duration: 2000
        });
      });
  }
})
